home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / include / linux / fs.h < prev    next >
Encoding:
C/C++ Source or Header  |  2009-10-16  |  14.4 KB  |  357 lines
  1. #ifndef _LINUX_FS_H
  2. #define _LINUX_FS_H
  3.  
  4. /*
  5.  * This file has definitions for some important file table
  6.  * structures etc.
  7.  */
  8.  
  9. #include <linux/limits.h>
  10. #include <linux/ioctl.h>
  11.  
  12. /*
  13.  * It's silly to have NR_OPEN bigger than NR_FILE, but you can change
  14.  * the file limit at runtime and only root can increase the per-process
  15.  * nr_file rlimit, so it's safe to set up a ridiculously high absolute
  16.  * upper limit on files-per-process.
  17.  *
  18.  * Some programs (notably those using select()) may have to be 
  19.  * recompiled to take full advantage of the new limits..  
  20.  */
  21.  
  22. /* Fixed constants first: */
  23. #undef NR_OPEN
  24. #define INR_OPEN 1024        /* Initial setting for nfile rlimits */
  25.  
  26. #define BLOCK_SIZE_BITS 10
  27. #define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)
  28.  
  29. #define SEEK_SET    0    /* seek relative to beginning of file */
  30. #define SEEK_CUR    1    /* seek relative to current file position */
  31. #define SEEK_END    2    /* seek relative to end of file */
  32. #define SEEK_MAX    SEEK_END
  33.  
  34. /* And dynamically-tunable limits and defaults: */
  35. struct files_stat_struct {
  36.     int nr_files;        /* read only */
  37.     int nr_free_files;    /* read only */
  38.     int max_files;        /* tunable */
  39. };
  40.  
  41. struct inodes_stat_t {
  42.     int nr_inodes;
  43.     int nr_unused;
  44.     int dummy[5];        /* padding for sysctl ABI compatibility */
  45. };
  46.  
  47.  
  48. #define NR_FILE  8192    /* this can well be larger on a larger system */
  49.  
  50. #define MAY_EXEC 1
  51. #define MAY_WRITE 2
  52. #define MAY_READ 4
  53. #define MAY_APPEND 8
  54. #define MAY_ACCESS 16
  55. #define MAY_OPEN 32
  56.  
  57. /*
  58.  * flags in file.f_mode.  Note that FMODE_READ and FMODE_WRITE must correspond
  59.  * to O_WRONLY and O_RDWR via the strange trick in __dentry_open()
  60.  */
  61.  
  62. /* file is open for reading */
  63. #define FMODE_READ        ((fmode_t)1)
  64. /* file is open for writing */
  65. #define FMODE_WRITE        ((fmode_t)2)
  66. /* file is seekable */
  67. #define FMODE_LSEEK        ((fmode_t)4)
  68. /* file can be accessed using pread */
  69. #define FMODE_PREAD        ((fmode_t)8)
  70. /* file can be accessed using pwrite */
  71. #define FMODE_PWRITE        ((fmode_t)16)
  72. /* File is opened for execution with sys_execve / sys_uselib */
  73. #define FMODE_EXEC        ((fmode_t)32)
  74. /* File is opened with O_NDELAY (only set for block devices) */
  75. #define FMODE_NDELAY        ((fmode_t)64)
  76. /* File is opened with O_EXCL (only set for block devices) */
  77. #define FMODE_EXCL        ((fmode_t)128)
  78. /* File is opened using open(.., 3, ..) and is writeable only for ioctls
  79.    (specialy hack for floppy.c) */
  80. #define FMODE_WRITE_IOCTL    ((fmode_t)256)
  81.  
  82. /*
  83.  * Don't update ctime and mtime.
  84.  *
  85.  * Currently a special hack for the XFS open_by_handle ioctl, but we'll
  86.  * hopefully graduate it to a proper O_CMTIME flag supported by open(2) soon.
  87.  */
  88. #define FMODE_NOCMTIME        ((fmode_t)2048)
  89.  
  90. /*
  91.  * The below are the various read and write types that we support. Some of
  92.  * them include behavioral modifiers that send information down to the
  93.  * block layer and IO scheduler. Terminology:
  94.  *
  95.  *    The block layer uses device plugging to defer IO a little bit, in
  96.  *    the hope that we will see more IO very shortly. This increases
  97.  *    coalescing of adjacent IO and thus reduces the number of IOs we
  98.  *    have to send to the device. It also allows for better queuing,
  99.  *    if the IO isn't mergeable. If the caller is going to be waiting
  100.  *    for the IO, then he must ensure that the device is unplugged so
  101.  *    that the IO is dispatched to the driver.
  102.  *
  103.  *    All IO is handled async in Linux. This is fine for background
  104.  *    writes, but for reads or writes that someone waits for completion
  105.  *    on, we want to notify the block layer and IO scheduler so that they
  106.  *    know about it. That allows them to make better scheduling
  107.  *    decisions. So when the below references 'sync' and 'async', it
  108.  *    is referencing this priority hint.
  109.  *
  110.  * With that in mind, the available types are:
  111.  *
  112.  * READ            A normal read operation. Device will be plugged.
  113.  * READ_SYNC        A synchronous read. Device is not plugged, caller can
  114.  *            immediately wait on this read without caring about
  115.  *            unplugging.
  116.  * READA        Used for read-ahead operations. Lower priority, and the
  117.  *             block layer could (in theory) choose to ignore this
  118.  *            request if it runs into resource problems.
  119.  * WRITE        A normal async write. Device will be plugged.
  120.  * SWRITE        Like WRITE, but a special case for ll_rw_block() that
  121.  *            tells it to lock the buffer first. Normally a buffer
  122.  *            must be locked before doing IO.
  123.  * WRITE_SYNC_PLUG    Synchronous write. Identical to WRITE, but passes down
  124.  *            the hint that someone will be waiting on this IO
  125.  *            shortly. The device must still be unplugged explicitly,
  126.  *            WRITE_SYNC_PLUG does not do this as we could be
  127.  *            submitting more writes before we actually wait on any
  128.  *            of them.
  129.  * WRITE_SYNC        Like WRITE_SYNC_PLUG, but also unplugs the device
  130.  *            immediately after submission. The write equivalent
  131.  *            of READ_SYNC.
  132.  * WRITE_ODIRECT    Special case write for O_DIRECT only.
  133.  * SWRITE_SYNC
  134.  * SWRITE_SYNC_PLUG    Like WRITE_SYNC/WRITE_SYNC_PLUG, but locks the buffer.
  135.  *            See SWRITE.
  136.  * WRITE_BARRIER    Like WRITE, but tells the block layer that all
  137.  *            previously submitted writes must be safely on storage
  138.  *            before this one is started. Also guarantees that when
  139.  *            this write is complete, it itself is also safely on
  140.  *            storage. Prevents reordering of writes on both sides
  141.  *            of this IO.
  142.  *
  143.  */
  144. #define RW_MASK        1
  145. #define RWA_MASK    2
  146. #define READ 0
  147. #define WRITE 1
  148. #define READA 2        /* read-ahead  - don't block if no resources */
  149. #define SWRITE 3    /* for ll_rw_block() - wait for buffer lock */
  150. #define READ_SYNC    (READ | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG))
  151. #define READ_META    (READ | (1 << BIO_RW_META))
  152. #define WRITE_SYNC_PLUG    (WRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_NOIDLE))
  153. #define WRITE_SYNC    (WRITE_SYNC_PLUG | (1 << BIO_RW_UNPLUG))
  154. #define WRITE_ODIRECT    (WRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG))
  155. #define SWRITE_SYNC_PLUG    \
  156.             (SWRITE | (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_NOIDLE))
  157. #define SWRITE_SYNC    (SWRITE_SYNC_PLUG | (1 << BIO_RW_UNPLUG))
  158. #define WRITE_BARRIER    (WRITE | (1 << BIO_RW_BARRIER))
  159.  
  160. /*
  161.  * These aren't really reads or writes, they pass down information about
  162.  * parts of device that are now unused by the file system.
  163.  */
  164. #define DISCARD_NOBARRIER (1 << BIO_RW_DISCARD)
  165. #define DISCARD_BARRIER ((1 << BIO_RW_DISCARD) | (1 << BIO_RW_BARRIER))
  166.  
  167. #define SEL_IN        1
  168. #define SEL_OUT        2
  169. #define SEL_EX        4
  170.  
  171. /* public flags for file_system_type */
  172. #define FS_REQUIRES_DEV 1 
  173. #define FS_BINARY_MOUNTDATA 2
  174. #define FS_HAS_SUBTYPE 4
  175. #define FS_REVAL_DOT    16384    /* Check the paths ".", ".." for staleness */
  176. #define FS_RENAME_DOES_D_MOVE    32768    /* FS will handle d_move()
  177.                      * during rename() internally.
  178.                      */
  179.  
  180. /*
  181.  * These are the fs-independent mount-flags: up to 32 flags are supported
  182.  */
  183. #define MS_RDONLY     1    /* Mount read-only */
  184. #define MS_NOSUID     2    /* Ignore suid and sgid bits */
  185. #define MS_NODEV     4    /* Disallow access to device special files */
  186. #define MS_NOEXEC     8    /* Disallow program execution */
  187. #define MS_SYNCHRONOUS    16    /* Writes are synced at once */
  188. #define MS_REMOUNT    32    /* Alter flags of a mounted FS */
  189. #define MS_MANDLOCK    64    /* Allow mandatory locks on an FS */
  190. #define MS_DIRSYNC    128    /* Directory modifications are synchronous */
  191. #define MS_NOATIME    1024    /* Do not update access times. */
  192. #define MS_NODIRATIME    2048    /* Do not update directory access times */
  193. #define MS_BIND        4096
  194. #define MS_MOVE        8192
  195. #define MS_REC        16384
  196. #define MS_VERBOSE    32768    /* War is peace. Verbosity is silence.
  197.                    MS_VERBOSE is deprecated. */
  198. #define MS_SILENT    32768
  199. #define MS_POSIXACL    (1<<16)    /* VFS does not apply the umask */
  200. #define MS_UNBINDABLE    (1<<17)    /* change to unbindable */
  201. #define MS_PRIVATE    (1<<18)    /* change to private */
  202. #define MS_SLAVE    (1<<19)    /* change to slave */
  203. #define MS_SHARED    (1<<20)    /* change to shared */
  204. #define MS_RELATIME    (1<<21)    /* Update atime relative to mtime/ctime. */
  205. #define MS_KERNMOUNT    (1<<22) /* this is a kern_mount call */
  206. #define MS_I_VERSION    (1<<23) /* Update inode I_version field */
  207. #define MS_STRICTATIME    (1<<24) /* Always perform atime updates */
  208. #define MS_ACTIVE    (1<<30)
  209. #define MS_NOUSER    (1<<31)
  210.  
  211. /*
  212.  * Superblock flags that can be altered by MS_REMOUNT
  213.  */
  214. #define MS_RMT_MASK    (MS_RDONLY|MS_SYNCHRONOUS|MS_MANDLOCK|MS_I_VERSION)
  215.  
  216. /*
  217.  * Old magic mount flag and mask
  218.  */
  219. #define MS_MGC_VAL 0xC0ED0000
  220. #define MS_MGC_MSK 0xffff0000
  221.  
  222. /* Inode flags - they have nothing to superblock flags now */
  223.  
  224. #define S_SYNC        1    /* Writes are synced at once */
  225. #define S_NOATIME    2    /* Do not update access times */
  226. #define S_APPEND    4    /* Append-only file */
  227. #define S_IMMUTABLE    8    /* Immutable file */
  228. #define S_DEAD        16    /* removed, but still open directory */
  229. #define S_NOQUOTA    32    /* Inode is not counted to quota */
  230. #define S_DIRSYNC    64    /* Directory modifications are synchronous */
  231. #define S_NOCMTIME    128    /* Do not update file c/mtime */
  232. #define S_SWAPFILE    256    /* Do not truncate: swapon got its bmaps */
  233. #define S_PRIVATE    512    /* Inode is fs-internal */
  234.  
  235. /*
  236.  * Note that nosuid etc flags are inode-specific: setting some file-system
  237.  * flags just means all the inodes inherit those flags by default. It might be
  238.  * possible to override it selectively if you really wanted to with some
  239.  * ioctl() that is not currently implemented.
  240.  *
  241.  * Exception: MS_RDONLY is always applied to the entire file system.
  242.  *
  243.  * Unfortunately, it is possible to change a filesystems flags with it mounted
  244.  * with files in use.  This means that all of the inodes will not have their
  245.  * i_flags updated.  Hence, i_flags no longer inherit the superblock mount
  246.  * flags, so these have to be checked separately. -- rmk@arm.uk.linux.org
  247.  */
  248. #define __IS_FLG(inode,flg) ((inode)->i_sb->s_flags & (flg))
  249.  
  250. #define IS_RDONLY(inode) ((inode)->i_sb->s_flags & MS_RDONLY)
  251. #define IS_SYNC(inode)        (__IS_FLG(inode, MS_SYNCHRONOUS) || \
  252.                     ((inode)->i_flags & S_SYNC))
  253. #define IS_DIRSYNC(inode)    (__IS_FLG(inode, MS_SYNCHRONOUS|MS_DIRSYNC) || \
  254.                     ((inode)->i_flags & (S_SYNC|S_DIRSYNC)))
  255. #define IS_MANDLOCK(inode)    __IS_FLG(inode, MS_MANDLOCK)
  256. #define IS_NOATIME(inode)   __IS_FLG(inode, MS_RDONLY|MS_NOATIME)
  257. #define IS_I_VERSION(inode)   __IS_FLG(inode, MS_I_VERSION)
  258.  
  259. #define IS_NOQUOTA(inode)    ((inode)->i_flags & S_NOQUOTA)
  260. #define IS_APPEND(inode)    ((inode)->i_flags & S_APPEND)
  261. #define IS_IMMUTABLE(inode)    ((inode)->i_flags & S_IMMUTABLE)
  262. #define IS_POSIXACL(inode)    __IS_FLG(inode, MS_POSIXACL)
  263.  
  264. #define IS_DEADDIR(inode)    ((inode)->i_flags & S_DEAD)
  265. #define IS_NOCMTIME(inode)    ((inode)->i_flags & S_NOCMTIME)
  266. #define IS_SWAPFILE(inode)    ((inode)->i_flags & S_SWAPFILE)
  267. #define IS_PRIVATE(inode)    ((inode)->i_flags & S_PRIVATE)
  268.  
  269. /* the read-only stuff doesn't really belong here, but any other place is
  270.    probably as bad and I don't want to create yet another include file. */
  271.  
  272. #define BLKROSET   _IO(0x12,93)    /* set device read-only (0 = read-write) */
  273. #define BLKROGET   _IO(0x12,94)    /* get read-only status (0 = read_write) */
  274. #define BLKRRPART  _IO(0x12,95)    /* re-read partition table */
  275. #define BLKGETSIZE _IO(0x12,96)    /* return device size /512 (long *arg) */
  276. #define BLKFLSBUF  _IO(0x12,97)    /* flush buffer cache */
  277. #define BLKRASET   _IO(0x12,98)    /* set read ahead for block device */
  278. #define BLKRAGET   _IO(0x12,99)    /* get current read ahead setting */
  279. #define BLKFRASET  _IO(0x12,100)/* set filesystem (mm/filemap.c) read-ahead */
  280. #define BLKFRAGET  _IO(0x12,101)/* get filesystem (mm/filemap.c) read-ahead */
  281. #define BLKSECTSET _IO(0x12,102)/* set max sectors per request (ll_rw_blk.c) */
  282. #define BLKSECTGET _IO(0x12,103)/* get max sectors per request (ll_rw_blk.c) */
  283. #define BLKSSZGET  _IO(0x12,104)/* get block device sector size */
  284. #if 0
  285. #define BLKPG      _IO(0x12,105)/* See blkpg.h */
  286.  
  287. /* Some people are morons.  Do not use sizeof! */
  288.  
  289. #define BLKELVGET  _IOR(0x12,106,size_t)/* elevator get */
  290. #define BLKELVSET  _IOW(0x12,107,size_t)/* elevator set */
  291. /* This was here just to show that the number is taken -
  292.    probably all these _IO(0x12,*) ioctls should be moved to blkpg.h. */
  293. #endif
  294. /* A jump here: 108-111 have been used for various private purposes. */
  295. #define BLKBSZGET  _IOR(0x12,112,size_t)
  296. #define BLKBSZSET  _IOW(0x12,113,size_t)
  297. #define BLKGETSIZE64 _IOR(0x12,114,size_t)    /* return device size in bytes (u64 *arg) */
  298. #define BLKTRACESETUP _IOWR(0x12,115,struct blk_user_trace_setup)
  299. #define BLKTRACESTART _IO(0x12,116)
  300. #define BLKTRACESTOP _IO(0x12,117)
  301. #define BLKTRACETEARDOWN _IO(0x12,118)
  302. #define BLKDISCARD _IO(0x12,119)
  303.  
  304. #define BMAP_IOCTL 1        /* obsolete - kept for compatibility */
  305. #define FIBMAP       _IO(0x00,1)    /* bmap access */
  306. #define FIGETBSZ   _IO(0x00,2)    /* get the block size used for bmap */
  307. #define FIFREEZE    _IOWR('X', 119, int)    /* Freeze */
  308. #define FITHAW        _IOWR('X', 120, int)    /* Thaw */
  309.  
  310. #define    FS_IOC_GETFLAGS            _IOR('f', 1, long)
  311. #define    FS_IOC_SETFLAGS            _IOW('f', 2, long)
  312. #define    FS_IOC_GETVERSION        _IOR('v', 1, long)
  313. #define    FS_IOC_SETVERSION        _IOW('v', 2, long)
  314. #define FS_IOC_FIEMAP            _IOWR('f', 11, struct fiemap)
  315. #define FS_IOC32_GETFLAGS        _IOR('f', 1, int)
  316. #define FS_IOC32_SETFLAGS        _IOW('f', 2, int)
  317. #define FS_IOC32_GETVERSION        _IOR('v', 1, int)
  318. #define FS_IOC32_SETVERSION        _IOW('v', 2, int)
  319.  
  320. /*
  321.  * Inode flags (FS_IOC_GETFLAGS / FS_IOC_SETFLAGS)
  322.  */
  323. #define    FS_SECRM_FL            0x00000001 /* Secure deletion */
  324. #define    FS_UNRM_FL            0x00000002 /* Undelete */
  325. #define    FS_COMPR_FL            0x00000004 /* Compress file */
  326. #define FS_SYNC_FL            0x00000008 /* Synchronous updates */
  327. #define FS_IMMUTABLE_FL            0x00000010 /* Immutable file */
  328. #define FS_APPEND_FL            0x00000020 /* writes to file may only append */
  329. #define FS_NODUMP_FL            0x00000040 /* do not dump file */
  330. #define FS_NOATIME_FL            0x00000080 /* do not update atime */
  331. /* Reserved for compression usage... */
  332. #define FS_DIRTY_FL            0x00000100
  333. #define FS_COMPRBLK_FL            0x00000200 /* One or more compressed clusters */
  334. #define FS_NOCOMP_FL            0x00000400 /* Don't compress */
  335. #define FS_ECOMPR_FL            0x00000800 /* Compression error */
  336. /* End compression flags --- maybe not all used */
  337. #define FS_BTREE_FL            0x00001000 /* btree format dir */
  338. #define FS_INDEX_FL            0x00001000 /* hash-indexed directory */
  339. #define FS_IMAGIC_FL            0x00002000 /* AFS directory */
  340. #define FS_JOURNAL_DATA_FL        0x00004000 /* Reserved for ext3 */
  341. #define FS_NOTAIL_FL            0x00008000 /* file tail should not be merged */
  342. #define FS_DIRSYNC_FL            0x00010000 /* dirsync behaviour (directories only) */
  343. #define FS_TOPDIR_FL            0x00020000 /* Top of directory hierarchies*/
  344. #define FS_EXTENT_FL            0x00080000 /* Extents */
  345. #define FS_DIRECTIO_FL            0x00100000 /* Use direct i/o */
  346. #define FS_RESERVED_FL            0x80000000 /* reserved for ext2 lib */
  347.  
  348. #define FS_FL_USER_VISIBLE        0x0003DFFF /* User visible flags */
  349. #define FS_FL_USER_MODIFIABLE        0x000380FF /* User modifiable flags */
  350.  
  351.  
  352. #define SYNC_FILE_RANGE_WAIT_BEFORE    1
  353. #define SYNC_FILE_RANGE_WRITE        2
  354. #define SYNC_FILE_RANGE_WAIT_AFTER    4
  355.  
  356. #endif /* _LINUX_FS_H */
  357.